﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ACAT.Core.WidgetManagement
{
    // public class MicroStopwatch : System.Diagnostics.Stopwatch
    // {
    //     private readonly double _microSecPerTick =
    //         1000000D / System.Diagnostics.Stopwatch.Frequency;

    //     public MicroStopwatch()
    //     {
    //         if (!System.Diagnostics.Stopwatch.IsHighResolution)
    //         {
    //             throw new Exception("On this system the high-resolution " +
    //                                 "performance counter is not available");
    //         }
    //     }

    //     public long ElapsedMicroseconds
    //     {
    //         get
    //         {
    //             return (long)(ElapsedTicks * _microSecPerTick);
    //         }
    //     }
    // }

    // /// <summary>
    // /// MicroTimer class
    // /// </summary>
    // public class MicroTimer
    // {
    //     private long _ignoreEventIfLateBy = long.MaxValue;

    //     private bool _stopTimer = true;

    //     private System.Threading.Thread _threadTimer = null;

    //     private long _timerIntervalInMicroSec = 0;

    //     private MicroStopwatch microStopwatch;

    //     private MicroStopwatch microSW = new MicroStopwatch();

    //     private Boolean swStarted = false;

    //     public MicroTimer()
    //     {
    //     }

    //     public MicroTimer(long timerIntervalInMicroseconds)
    //     {
    //         Interval = timerIntervalInMicroseconds;
    //     }

    //     public delegate void MicroTimerElapsedEventHandler(object sender,
    //                          MicroTimerEventArgs timerEventArgs);

    //     public event MicroTimerElapsedEventHandler MicroTimerElapsed;

    //     public bool Enabled
    //     {
    //         set
    //         {
    //             if (value)
    //             {
    //                 Start();
    //             }
    //             else
    //             {
    //                 Stop();
    //             }
    //         }
    //         get
    //         {
    //             return (_threadTimer != null && _threadTimer.IsAlive);
    //         }
    //     }

    //     public long IgnoreEventIfLateBy
    //     {
    //         get
    //         {
    //             return System.Threading.Interlocked.Read(ref _ignoreEventIfLateBy);
    //         }
    //         set
    //         {
    //             System.Threading.Interlocked.Exchange(ref _ignoreEventIfLateBy, value <= 0 ? long.MaxValue : value);
    //         }
    //     }

    //     public long Interval
    //     {
    //         get
    //         {
    //             return System.Threading.Interlocked.Read(ref _timerIntervalInMicroSec);
    //         }
    //         set
    //         {
    //             System.Threading.Interlocked.Exchange(ref _timerIntervalInMicroSec, value);
    //         }
    //     }

    //     public void Abort()
    //     {
    //         _stopTimer = true;
    //         //microStopwatch.Stop();

    //         if (Enabled)
    //         {
    //             _threadTimer.Abort();
    //         }
    //     }

    //     public long ElapsedMicroseconds()
    //     {
    //         //return microSW.ElapsedMicroseconds;
    //         return microStopwatch.ElapsedMicroseconds;
    //     }

    //     public void Start()
    //     {
    //         if (Enabled || Interval <= 0)
    //         {
    //             return;
    //         }

    //         _stopTimer = false;

    //         System.Threading.ThreadStart threadStart = delegate ()
    //         {
    //             NotificationTimer(ref _timerIntervalInMicroSec,
    //                               ref _ignoreEventIfLateBy,
    //                               ref _stopTimer);
    //         };

    //         _threadTimer = new System.Threading.Thread(threadStart);
    //         _threadTimer.Priority = System.Threading.ThreadPriority.Highest;
    //         _threadTimer.Start();
    //     }

    //     public void Stop()
    //     {
    //         _stopTimer = true;
    //     }

    //     public void StopAndWait()
    //     {
    //         StopAndWait(System.Threading.Timeout.Infinite);
    //     }

    //     public bool StopAndWait(int timeoutInMilliSec)
    //     {
    //         _stopTimer = true;

    //         if (!Enabled || _threadTimer.ManagedThreadId == System.Threading.Thread.CurrentThread.ManagedThreadId)
    //         {
    //             return true;
    //         }

    //         return _threadTimer.Join(timeoutInMilliSec);
    //     }

    //     private void NotificationTimer(ref long timerIntervalInMicroSec,
    //                            ref long ignoreEventIfLateBy,
    //                            ref bool stopTimer)
    //     {
    //         int timerCount = 0;
    //         long nextNotification = 0;

    //         //MicroStopwatch microStopwatch = new MicroStopwatch();
    //         microStopwatch = new MicroStopwatch();
    //         microStopwatch.Start();
    //         /*
    //         if (!swStarted)
    //         {
    //             microSW.Start();
    //             swStarted = true;
    //         }
    //         */
    //         while (!stopTimer)
    //         {
    //             long callbackFunctionExecutionTime =
    //                 microStopwatch.ElapsedMicroseconds - nextNotification;

    //             long timerIntervalInMicroSecCurrent =
    //                 System.Threading.Interlocked.Read(ref timerIntervalInMicroSec);
    //             long ignoreEventIfLateByCurrent =
    //                 System.Threading.Interlocked.Read(ref ignoreEventIfLateBy);

    //             nextNotification += timerIntervalInMicroSecCurrent;
    //             timerCount++;
    //             long elapsedMicroseconds = 0;

    //             while ((elapsedMicroseconds = microStopwatch.ElapsedMicroseconds)
    //                     < nextNotification)
    //             {
    //                 System.Threading.Thread.SpinWait(10);
    //             }

    //             long timerLateBy = elapsedMicroseconds - nextNotification;

    //             if (timerLateBy >= ignoreEventIfLateByCurrent)
    //             {
    //                 continue;
    //             }

    //             MicroTimerEventArgs microTimerEventArgs =
    //                  new MicroTimerEventArgs(timerCount,
    //                                          elapsedMicroseconds,
    //                                          timerLateBy,
    //                                          callbackFunctionExecutionTime);
    //             MicroTimerElapsed(this, microTimerEventArgs);
    //         }

    //         microStopwatch.Stop();
    //         // microSW.Stop();
    //     }
    // }

    // /// <summary>
    // /// MicroTimer Event Argument class
    // /// </summary>
    // public class MicroTimerEventArgs : EventArgs
    // {
    //     public MicroTimerEventArgs(int timerCount,
    //                                        long elapsedMicroseconds,
    //                                        long timerLateBy,
    //                                        long callbackFunctionExecutionTime)
    //     {
    //         TimerCount = timerCount;
    //         ElapsedMicroseconds = elapsedMicroseconds;
    //         TimerLateBy = timerLateBy;
    //         CallbackFunctionExecutionTime = callbackFunctionExecutionTime;
    //     }

    //     // Time it took to execute previous call to callback function (OnTimedEvent)
    //     public long CallbackFunctionExecutionTime { get; private set; }

    //     // Time when timed event was called since timer started
    //     public long ElapsedMicroseconds { get; private set; }

    //     // Simple counter, number times timed event (callback function) executed
    //     public int TimerCount { get; private set; }

    //     // How late the timer was compared to when it should have been called
    //     public long TimerLateBy { get; private set; }
    // }
}